using System;
using System.Collections.Generic;
using System.Drawing;
using System.IO;
using System.Reflection;
using 游戏服务器.模板类;

namespace 游戏服务器.数据类
{
	public sealed class 数据字段
	{
		internal static readonly Dictionary<Type, Func<BinaryReader, 游戏数据, 数据字段, object>> 字段读取方法表;

		internal static readonly Dictionary<Type, Action<BinaryWriter, object>> 字段写入方法表;

		public string 字段名字 { get; }

		public Type 字段类型 { get; }

		public FieldInfo 字段详情 { get; }

		static 数据字段()
		{
			Class2.sov79KqzBKBU1();
			数据字段.字段读取方法表 = new Dictionary<Type, Func<BinaryReader, 游戏数据, 数据字段, object>>
			{
				[typeof(数据监视器<int>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					数据监视器<int> obj22;
					obj22 = new 数据监视器<int>(o);
					obj22.QuietlySetValue(r.ReadInt32());
					return obj22;
				},
				[typeof(数据监视器<uint>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					数据监视器<uint> obj21;
					obj21 = new 数据监视器<uint>(o);
					obj21.QuietlySetValue(r.ReadUInt32());
					return obj21;
				},
				[typeof(数据监视器<long>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					数据监视器<long> obj20;
					obj20 = new 数据监视器<long>(o);
					obj20.QuietlySetValue(r.ReadInt64());
					return obj20;
				},
				[typeof(数据监视器<bool>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					数据监视器<bool> obj19;
					obj19 = new 数据监视器<bool>(o);
					obj19.QuietlySetValue(r.ReadBoolean());
					return obj19;
				},
				[typeof(数据监视器<byte>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					数据监视器<byte> obj18;
					obj18 = new 数据监视器<byte>(o);
					obj18.QuietlySetValue(r.ReadByte());
					return obj18;
				},
				[typeof(数据监视器<sbyte>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					数据监视器<sbyte> obj17;
					obj17 = new 数据监视器<sbyte>(o);
					obj17.QuietlySetValue(r.ReadSByte());
					return obj17;
				},
				[typeof(数据监视器<string>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					数据监视器<string> obj16;
					obj16 = new 数据监视器<string>(o);
					obj16.QuietlySetValue(r.ReadString());
					return obj16;
				},
				[typeof(数据监视器<ushort>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					数据监视器<ushort> obj15;
					obj15 = new 数据监视器<ushort>(o);
					obj15.QuietlySetValue(r.ReadUInt16());
					return obj15;
				},
				[typeof(数据监视器<Point>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					数据监视器<Point> obj14;
					obj14 = new 数据监视器<Point>(o);
					obj14.QuietlySetValue(new Point(r.ReadInt32(), r.ReadInt32()));
					return obj14;
				},
				[typeof(数据监视器<TimeSpan>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					数据监视器<TimeSpan> obj13;
					obj13 = new 数据监视器<TimeSpan>(o);
					obj13.QuietlySetValue(TimeSpan.FromTicks(r.ReadInt64()));
					return obj13;
				},
				[typeof(数据监视器<DateTime>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					数据监视器<DateTime> obj12;
					obj12 = new 数据监视器<DateTime>(o);
					obj12.QuietlySetValue(DateTime.FromBinary(r.ReadInt64()));
					return obj12;
				},
				[typeof(数据监视器<随机属性>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					数据监视器<随机属性> obj11;
					obj11 = new 数据监视器<随机属性>(o);
					obj11.QuietlySetValue(随机属性.数据表.TryGetValue(r.ReadInt32(), out var value6) ? value6 : null);
					return obj11;
				},
				[typeof(数据监视器<铭文技能>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					数据监视器<铭文技能> obj10;
					obj10 = new 数据监视器<铭文技能>(o);
					obj10.QuietlySetValue(铭文技能.数据表.TryGetValue(r.ReadUInt16(), out var value5) ? value5 : null);
					return obj10;
				},
				[typeof(数据监视器<游戏物品>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					数据监视器<游戏物品> obj9;
					obj9 = new 数据监视器<游戏物品>(o);
					obj9.QuietlySetValue(游戏物品.数据表.TryGetValue(r.ReadInt32(), out var value4) ? value4 : null);
					return obj9;
				},
				[typeof(数据监视器<宠物模式>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					数据监视器<宠物模式> obj8;
					obj8 = new 数据监视器<宠物模式>(o);
					obj8.QuietlySetValue((宠物模式)r.ReadInt32());
					return obj8;
				},
				[typeof(数据监视器<攻击模式>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					数据监视器<攻击模式> obj7;
					obj7 = new 数据监视器<攻击模式>(o);
					obj7.QuietlySetValue((攻击模式)r.ReadInt32());
					return obj7;
				},
				[typeof(数据监视器<游戏方向>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					数据监视器<游戏方向> obj6;
					obj6 = new 数据监视器<游戏方向>(o);
					obj6.QuietlySetValue((游戏方向)r.ReadInt32());
					return obj6;
				},
				[typeof(数据监视器<对象发型分类>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					数据监视器<对象发型分类> obj5;
					obj5 = new 数据监视器<对象发型分类>(o);
					obj5.QuietlySetValue((对象发型分类)r.ReadInt32());
					return obj5;
				},
				[typeof(数据监视器<对象发色分类>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					数据监视器<对象发色分类> obj4;
					obj4 = new 数据监视器<对象发色分类>(o);
					obj4.QuietlySetValue((对象发色分类)r.ReadInt32());
					return obj4;
				},
				[typeof(数据监视器<对象脸型分类>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					数据监视器<对象脸型分类> obj3;
					obj3 = new 数据监视器<对象脸型分类>(o);
					obj3.QuietlySetValue((对象脸型分类)r.ReadInt32());
					return obj3;
				},
				[typeof(数据监视器<游戏对象性别>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					数据监视器<游戏对象性别> obj2;
					obj2 = new 数据监视器<游戏对象性别>(o);
					obj2.QuietlySetValue((游戏对象性别)r.ReadInt32());
					return obj2;
				},
				[typeof(数据监视器<游戏对象职业>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					数据监视器<游戏对象职业> obj;
					obj = new 数据监视器<游戏对象职业>(o);
					obj.QuietlySetValue((游戏对象职业)r.ReadInt32());
					return obj;
				},
				[typeof(数据监视器<师门数据>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					数据监视器<师门数据> 数据监视器11;
					数据监视器11 = new 数据监视器<师门数据>(o);
					数据关联表.添加任务(o, f, 数据监视器11, typeof(师门数据), r.ReadInt32());
					return 数据监视器11;
				},
				[typeof(数据监视器<行会数据>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					数据监视器<行会数据> 数据监视器10;
					数据监视器10 = new 数据监视器<行会数据>(o);
					数据关联表.添加任务(o, f, 数据监视器10, typeof(行会数据), r.ReadInt32());
					return 数据监视器10;
				},
				[typeof(数据监视器<队伍数据>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					数据监视器<队伍数据> 数据监视器9;
					数据监视器9 = new 数据监视器<队伍数据>(o);
					数据关联表.添加任务(o, f, 数据监视器9, typeof(队伍数据), r.ReadInt32());
					return 数据监视器9;
				},
				[typeof(数据监视器<Buff数据>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					数据监视器<Buff数据> 数据监视器8;
					数据监视器8 = new 数据监视器<Buff数据>(o);
					数据关联表.添加任务(o, f, 数据监视器8, typeof(Buff数据), r.ReadInt32());
					return 数据监视器8;
				},
				[typeof(数据监视器<邮件数据>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					数据监视器<邮件数据> 数据监视器7;
					数据监视器7 = new 数据监视器<邮件数据>(o);
					数据关联表.添加任务(o, f, 数据监视器7, typeof(邮件数据), r.ReadInt32());
					return 数据监视器7;
				},
				[typeof(数据监视器<账号数据>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					数据监视器<账号数据> 数据监视器6;
					数据监视器6 = new 数据监视器<账号数据>(o);
					数据关联表.添加任务(o, f, 数据监视器6, typeof(账号数据), r.ReadInt32());
					return 数据监视器6;
				},
				[typeof(数据监视器<角色数据>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					数据监视器<角色数据> 数据监视器5;
					数据监视器5 = new 数据监视器<角色数据>(o);
					数据关联表.添加任务(o, f, 数据监视器5, typeof(角色数据), r.ReadInt32());
					return 数据监视器5;
				},
				[typeof(数据监视器<装备数据>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					数据监视器<装备数据> 数据监视器4;
					数据监视器4 = new 数据监视器<装备数据>(o);
					数据关联表.添加任务(o, f, 数据监视器4, typeof(装备数据), r.ReadInt32());
					return 数据监视器4;
				},
				[typeof(数据监视器<物品数据>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					数据监视器<物品数据> 数据监视器3;
					数据监视器3 = new 数据监视器<物品数据>(o);
					数据关联表.添加任务(o, f, 数据监视器3, r.ReadBoolean() ? typeof(装备数据) : typeof(物品数据), r.ReadInt32());
					return 数据监视器3;
				},
				[typeof(列表监视器<int>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					列表监视器<int> 列表监视器21;
					列表监视器21 = new 列表监视器<int>(o);
					int num61;
					num61 = r.ReadInt32();
					for (int num62 = 0; num62 < num61; num62++)
					{
						列表监视器21.QuietlyAdd(r.ReadInt32());
					}
					return 列表监视器21;
				},
				[typeof(列表监视器<uint>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					列表监视器<uint> 列表监视器20;
					列表监视器20 = new 列表监视器<uint>(o);
					int num59;
					num59 = r.ReadInt32();
					for (int num60 = 0; num60 < num59; num60++)
					{
						列表监视器20.QuietlyAdd(r.ReadUInt32());
					}
					return 列表监视器20;
				},
				[typeof(列表监视器<bool>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					列表监视器<bool> 列表监视器19;
					列表监视器19 = new 列表监视器<bool>(o);
					int num57;
					num57 = r.ReadInt32();
					for (int num58 = 0; num58 < num57; num58++)
					{
						列表监视器19.QuietlyAdd(r.ReadBoolean());
					}
					return 列表监视器19;
				},
				[typeof(列表监视器<byte>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					列表监视器<byte> 列表监视器18;
					列表监视器18 = new 列表监视器<byte>(o);
					int num55;
					num55 = r.ReadInt32();
					for (int num56 = 0; num56 < num55; num56++)
					{
						列表监视器18.QuietlyAdd(r.ReadByte());
					}
					return 列表监视器18;
				},
				[typeof(列表监视器<角色数据>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					列表监视器<角色数据> 列表监视器17;
					列表监视器17 = new 列表监视器<角色数据>(o);
					int num53;
					num53 = r.ReadInt32();
					for (int num54 = 0; num54 < num53; num54++)
					{
						数据关联表.添加任务(o, f, 列表监视器17.IList, typeof(角色数据), r.ReadInt32());
					}
					return 列表监视器17;
				},
				[typeof(列表监视器<宠物数据>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					列表监视器<宠物数据> 列表监视器16;
					列表监视器16 = new 列表监视器<宠物数据>(o);
					int num51;
					num51 = r.ReadInt32();
					for (int num52 = 0; num52 < num51; num52++)
					{
						数据关联表.添加任务(o, f, 列表监视器16.IList, typeof(宠物数据), r.ReadInt32());
					}
					return 列表监视器16;
				},
				[typeof(列表监视器<行会数据>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					列表监视器<行会数据> 列表监视器15;
					列表监视器15 = new 列表监视器<行会数据>(o);
					int num49;
					num49 = r.ReadInt32();
					for (int num50 = 0; num50 < num49; num50++)
					{
						数据关联表.添加任务(o, f, 列表监视器15.IList, typeof(行会数据), r.ReadInt32());
					}
					return 列表监视器15;
				},
				[typeof(列表监视器<行会事记>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					列表监视器<行会事记> 列表监视器14;
					列表监视器14 = new 列表监视器<行会事记>(o);
					int num47;
					num47 = r.ReadInt32();
					for (int num48 = 0; num48 < num47; num48++)
					{
						列表监视器14.QuietlyAdd(new 行会事记
						{
							事记类型 = (事记类型)r.ReadByte(),
							第一参数 = r.ReadInt32(),
							第二参数 = r.ReadInt32(),
							第三参数 = r.ReadInt32(),
							第四参数 = r.ReadInt32(),
							事记时间 = r.ReadInt32()
						});
					}
					return 列表监视器14;
				},
				[typeof(列表监视器<随机属性>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					列表监视器<随机属性> 列表监视器13;
					列表监视器13 = new 列表监视器<随机属性>(o);
					int num45;
					num45 = r.ReadInt32();
					for (int num46 = 0; num46 < num45; num46++)
					{
						if (随机属性.数据表.TryGetValue(r.ReadInt32(), out var value3))
						{
							列表监视器13.QuietlyAdd(value3);
						}
					}
					return 列表监视器13;
				},
				[typeof(列表监视器<装备孔洞颜色>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					列表监视器<装备孔洞颜色> 列表监视器12;
					列表监视器12 = new 列表监视器<装备孔洞颜色>(o);
					int num43;
					num43 = r.ReadInt32();
					for (int num44 = 0; num44 < num43; num44++)
					{
						列表监视器12.QuietlyAdd((装备孔洞颜色)r.ReadInt32());
					}
					return 列表监视器12;
				},
				[typeof(哈希监视器<宠物数据>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					哈希监视器<宠物数据> 哈希监视器7;
					哈希监视器7 = new 哈希监视器<宠物数据>(o);
					int num41;
					num41 = r.ReadInt32();
					for (int num42 = 0; num42 < num41; num42++)
					{
						数据关联表.添加任务(o, f, 哈希监视器7.ISet, r.ReadInt32());
					}
					return 哈希监视器7;
				},
				[typeof(哈希监视器<角色数据>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					哈希监视器<角色数据> 哈希监视器6;
					哈希监视器6 = new 哈希监视器<角色数据>(o);
					int num39;
					num39 = r.ReadInt32();
					for (int num40 = 0; num40 < num39; num40++)
					{
						数据关联表.添加任务(o, f, 哈希监视器6.ISet, r.ReadInt32());
					}
					return 哈希监视器6;
				},
				[typeof(哈希监视器<邮件数据>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					哈希监视器<邮件数据> 哈希监视器5;
					哈希监视器5 = new 哈希监视器<邮件数据>(o);
					int num37;
					num37 = r.ReadInt32();
					for (int num38 = 0; num38 < num37; num38++)
					{
						数据关联表.添加任务(o, f, 哈希监视器5.ISet, r.ReadInt32());
					}
					return 哈希监视器5;
				},
				[typeof(字典监视器<byte, int>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					字典监视器<byte, int> 字典监视器39;
					字典监视器39 = new 字典监视器<byte, int>(o);
					int num35;
					num35 = r.ReadInt32();
					for (int num36 = 0; num36 < num35; num36++)
					{
						字典监视器39.QuietlyAdd(r.ReadByte(), r.ReadInt32());
					}
					return 字典监视器39;
				},
				[typeof(字典监视器<int, int>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					字典监视器<int, int> 字典监视器38;
					字典监视器38 = new 字典监视器<int, int>(o);
					int num33;
					num33 = r.ReadInt32();
					for (int num34 = 0; num34 < num33; num34++)
					{
						字典监视器38.QuietlyAdd(r.ReadInt32(), r.ReadInt32());
					}
					return 字典监视器38;
				},
				[typeof(字典监视器<int, DateTime>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					字典监视器<int, DateTime> 字典监视器37;
					字典监视器37 = new 字典监视器<int, DateTime>(o);
					int num31;
					num31 = r.ReadInt32();
					for (int num32 = 0; num32 < num31; num32++)
					{
						字典监视器37.QuietlyAdd(r.ReadInt32(), DateTime.FromBinary(r.ReadInt64()));
					}
					return 字典监视器37;
				},
				[typeof(字典监视器<byte, DateTime>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					字典监视器<byte, DateTime> 字典监视器36;
					字典监视器36 = new 字典监视器<byte, DateTime>(o);
					int num29;
					num29 = r.ReadInt32();
					for (int num30 = 0; num30 < num29; num30++)
					{
						字典监视器36.QuietlyAdd(r.ReadByte(), DateTime.FromBinary(r.ReadInt64()));
					}
					return 字典监视器36;
				},
				[typeof(字典监视器<string, DateTime>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					字典监视器<string, DateTime> 字典监视器35;
					字典监视器35 = new 字典监视器<string, DateTime>(o);
					int num27;
					num27 = r.ReadInt32();
					for (int num28 = 0; num28 < num27; num28++)
					{
						字典监视器35.QuietlyAdd(r.ReadString(), DateTime.FromBinary(r.ReadInt64()));
					}
					return 字典监视器35;
				},
				[typeof(字典监视器<byte, 游戏物品>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					字典监视器<byte, 游戏物品> 字典监视器34;
					字典监视器34 = new 字典监视器<byte, 游戏物品>(o);
					int num25;
					num25 = r.ReadInt32();
					for (int num26 = 0; num26 < num25; num26++)
					{
						byte key3;
						key3 = r.ReadByte();
						int key4;
						key4 = r.ReadInt32();
						if (游戏物品.数据表.TryGetValue(key4, out var value2))
						{
							字典监视器34.QuietlyAdd(key3, value2);
						}
					}
					return 字典监视器34;
				},
				[typeof(字典监视器<byte, 铭文技能>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					字典监视器<byte, 铭文技能> 字典监视器33;
					字典监视器33 = new 字典监视器<byte, 铭文技能>(o);
					int num23;
					num23 = r.ReadInt32();
					for (int num24 = 0; num24 < num23; num24++)
					{
						byte key;
						key = r.ReadByte();
						ushort key2;
						key2 = r.ReadUInt16();
						if (铭文技能.数据表.TryGetValue(key2, out var value))
						{
							字典监视器33.QuietlyAdd(key, value);
						}
					}
					return 字典监视器33;
				},
				[typeof(字典监视器<ushort, Buff数据>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					字典监视器<ushort, Buff数据> 字典监视器32;
					字典监视器32 = new 字典监视器<ushort, Buff数据>(o);
					int num20;
					num20 = r.ReadInt32();
					for (int num21 = 0; num21 < num20; num21++)
					{
						ushort num22;
						num22 = r.ReadUInt16();
						数据关联表.添加任务(值索引: r.ReadInt32(), 数据: o, 字段: f, 内部字典: 字典监视器32.IDictionary_0, 字典键: num22, 字典值: null, 键类型: typeof(ushort), 值类型: typeof(Buff数据), 键索引: 0);
					}
					return 字典监视器32;
				},
				[typeof(字典监视器<ushort, 技能数据>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					字典监视器<ushort, 技能数据> 字典监视器31;
					字典监视器31 = new 字典监视器<ushort, 技能数据>(o);
					int num17;
					num17 = r.ReadInt32();
					for (int num18 = 0; num18 < num17; num18++)
					{
						ushort num19;
						num19 = r.ReadUInt16();
						数据关联表.添加任务(值索引: r.ReadInt32(), 数据: o, 字段: f, 内部字典: 字典监视器31.IDictionary_0, 字典键: num19, 字典值: null, 键类型: typeof(ushort), 值类型: typeof(技能数据), 键索引: 0);
					}
					return 字典监视器31;
				},
				[typeof(字典监视器<byte, 技能数据>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					字典监视器<byte, 技能数据> 字典监视器30;
					字典监视器30 = new 字典监视器<byte, 技能数据>(o);
					int num15;
					num15 = r.ReadInt32();
					for (int num16 = 0; num16 < num15; num16++)
					{
						byte b4;
						b4 = r.ReadByte();
						数据关联表.添加任务(值索引: r.ReadInt32(), 数据: o, 字段: f, 内部字典: 字典监视器30.IDictionary_0, 字典键: b4, 字典值: null, 键类型: typeof(byte), 值类型: typeof(技能数据), 键索引: 0);
					}
					return 字典监视器30;
				},
				[typeof(字典监视器<byte, 装备数据>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					字典监视器<byte, 装备数据> 字典监视器29;
					字典监视器29 = new 字典监视器<byte, 装备数据>(o);
					int num13;
					num13 = r.ReadInt32();
					for (int num14 = 0; num14 < num13; num14++)
					{
						byte b3;
						b3 = r.ReadByte();
						数据关联表.添加任务(值索引: r.ReadInt32(), 数据: o, 字段: f, 内部字典: 字典监视器29.IDictionary_0, 字典键: b3, 字典值: null, 键类型: typeof(byte), 值类型: typeof(装备数据), 键索引: 0);
					}
					return 字典监视器29;
				},
				[typeof(字典监视器<byte, 物品数据>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					字典监视器<byte, 物品数据> 字典监视器28;
					字典监视器28 = new 字典监视器<byte, 物品数据>(o);
					int num11;
					num11 = r.ReadInt32();
					for (int num12 = 0; num12 < num11; num12++)
					{
						byte b2;
						b2 = r.ReadByte();
						bool flag;
						flag = r.ReadBoolean();
						数据关联表.添加任务(值索引: r.ReadInt32(), 数据: o, 字段: f, 内部字典: 字典监视器28.IDictionary_0, 字典键: b2, 字典值: null, 键类型: typeof(byte), 值类型: flag ? typeof(装备数据) : typeof(物品数据), 键索引: 0);
					}
					return 字典监视器28;
				},
				[typeof(字典监视器<int, 角色数据>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					字典监视器<int, 角色数据> 字典监视器27;
					字典监视器27 = new 字典监视器<int, 角色数据>(o);
					int num8;
					num8 = r.ReadInt32();
					for (int num9 = 0; num9 < num8; num9++)
					{
						int num10;
						num10 = r.ReadInt32();
						数据关联表.添加任务(值索引: r.ReadInt32(), 数据: o, 字段: f, 内部字典: 字典监视器27.IDictionary_0, 字典键: num10, 字典值: null, 键类型: typeof(int), 值类型: typeof(角色数据), 键索引: 0);
					}
					return 字典监视器27;
				},
				[typeof(字典监视器<int, 邮件数据>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					字典监视器<int, 邮件数据> 字典监视器26;
					字典监视器26 = new 字典监视器<int, 邮件数据>(o);
					int num6;
					num6 = r.ReadInt32();
					for (int n = 0; n < num6; n++)
					{
						int num7;
						num7 = r.ReadInt32();
						数据关联表.添加任务(值索引: r.ReadInt32(), 数据: o, 字段: f, 内部字典: 字典监视器26.IDictionary_0, 字典键: num7, 字典值: null, 键类型: typeof(int), 值类型: typeof(邮件数据), 键索引: 0);
					}
					return 字典监视器26;
				},
				[typeof(字典监视器<游戏货币, int>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					字典监视器<游戏货币, int> 字典监视器25;
					字典监视器25 = new 字典监视器<游戏货币, int>(o);
					int num5;
					num5 = r.ReadInt32();
					for (int m = 0; m < num5; m++)
					{
						字典监视器25.QuietlyAdd((游戏货币)r.ReadInt32(), r.ReadInt32());
					}
					return 字典监视器25;
				},
				[typeof(字典监视器<行会数据, DateTime>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					字典监视器<行会数据, DateTime> 字典监视器24;
					字典监视器24 = new 字典监视器<行会数据, DateTime>(o);
					int num4;
					num4 = r.ReadInt32();
					for (int l = 0; l < num4; l++)
					{
						数据关联表.添加任务(键索引: r.ReadInt32(), 字典值: DateTime.FromBinary(r.ReadInt64()), 数据: o, 字段: f, 内部字典: 字典监视器24.IDictionary_0, 字典键: null, 键类型: typeof(行会数据), 值类型: typeof(DateTime), 值索引: 0);
					}
					return 字典监视器24;
				},
				[typeof(字典监视器<角色数据, DateTime>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					字典监视器<角色数据, DateTime> 字典监视器23;
					字典监视器23 = new 字典监视器<角色数据, DateTime>(o);
					int num3;
					num3 = r.ReadInt32();
					for (int k = 0; k < num3; k++)
					{
						数据关联表.添加任务(键索引: r.ReadInt32(), 字典值: DateTime.FromBinary(r.ReadInt64()), 数据: o, 字段: f, 内部字典: 字典监视器23.IDictionary_0, 字典键: null, 键类型: typeof(角色数据), 值类型: typeof(DateTime), 值索引: 0);
					}
					return 字典监视器23;
				},
				[typeof(字典监视器<角色数据, 行会职位>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					字典监视器<角色数据, 行会职位> 字典监视器22;
					字典监视器22 = new 字典监视器<角色数据, 行会职位>(o);
					int num2;
					num2 = r.ReadInt32();
					for (int j = 0; j < num2; j++)
					{
						数据关联表.添加任务(键索引: r.ReadInt32(), 字典值: (行会职位)r.ReadInt32(), 数据: o, 字段: f, 内部字典: 字典监视器22.IDictionary_0, 字典键: null, 键类型: typeof(角色数据), 值类型: typeof(行会职位), 值索引: 0);
					}
					return 字典监视器22;
				},
				[typeof(字典监视器<DateTime, 行会数据>)] = delegate(BinaryReader r, 游戏数据 o, 数据字段 f)
				{
					字典监视器<DateTime, 行会数据> 字典监视器21;
					字典监视器21 = new 字典监视器<DateTime, 行会数据>(o);
					int num;
					num = r.ReadInt32();
					for (int i = 0; i < num; i++)
					{
						long dateData;
						dateData = r.ReadInt64();
						数据关联表.添加任务(值索引: r.ReadInt32(), 数据: o, 字段: f, 内部字典: 字典监视器21.IDictionary_0, 字典键: DateTime.FromBinary(dateData), 字典值: null, 键类型: typeof(DateTime), 值类型: typeof(行会数据), 键索引: 0);
					}
					return 字典监视器21;
				}
			};
			数据字段.字段写入方法表 = new Dictionary<Type, Action<BinaryWriter, object>>
			{
				[typeof(数据监视器<int>)] = delegate(BinaryWriter b, object o)
				{
					b.Write(((数据监视器<int>)o).V);
				},
				[typeof(数据监视器<uint>)] = delegate(BinaryWriter b, object o)
				{
					b.Write(((数据监视器<uint>)o).V);
				},
				[typeof(数据监视器<long>)] = delegate(BinaryWriter b, object o)
				{
					b.Write(((数据监视器<long>)o).V);
				},
				[typeof(数据监视器<bool>)] = delegate(BinaryWriter b, object o)
				{
					b.Write(((数据监视器<bool>)o).V);
				},
				[typeof(数据监视器<byte>)] = delegate(BinaryWriter b, object o)
				{
					b.Write(((数据监视器<byte>)o).V);
				},
				[typeof(数据监视器<sbyte>)] = delegate(BinaryWriter b, object o)
				{
					b.Write(((数据监视器<sbyte>)o).V);
				},
				[typeof(数据监视器<string>)] = delegate(BinaryWriter b, object o)
				{
					b.Write(((数据监视器<string>)o).V ?? "");
				},
				[typeof(数据监视器<ushort>)] = delegate(BinaryWriter b, object o)
				{
					b.Write(((数据监视器<ushort>)o).V);
				},
				[typeof(数据监视器<Point>)] = delegate(BinaryWriter b, object o)
				{
					b.Write(((数据监视器<Point>)o).V.X);
					b.Write(((数据监视器<Point>)o).V.Y);
				},
				[typeof(数据监视器<TimeSpan>)] = delegate(BinaryWriter b, object o)
				{
					b.Write(((数据监视器<TimeSpan>)o).V.Ticks);
				},
				[typeof(数据监视器<DateTime>)] = delegate(BinaryWriter b, object o)
				{
					b.Write(((数据监视器<DateTime>)o).V.ToBinary());
				},
				[typeof(数据监视器<随机属性>)] = delegate(BinaryWriter b, object o)
				{
					b.Write(((数据监视器<随机属性>)o).V?.属性编号 ?? 0);
				},
				[typeof(数据监视器<铭文技能>)] = delegate(BinaryWriter b, object o)
				{
					b.Write(((数据监视器<铭文技能>)o).V?.铭文索引 ?? 0);
				},
				[typeof(数据监视器<游戏物品>)] = delegate(BinaryWriter b, object o)
				{
					b.Write(((数据监视器<游戏物品>)o).V?.物品编号 ?? 0);
				},
				[typeof(数据监视器<宠物模式>)] = delegate(BinaryWriter b, object o)
				{
					b.Write((int)((数据监视器<宠物模式>)o).V);
				},
				[typeof(数据监视器<攻击模式>)] = delegate(BinaryWriter b, object o)
				{
					b.Write((int)((数据监视器<攻击模式>)o).V);
				},
				[typeof(数据监视器<游戏方向>)] = delegate(BinaryWriter b, object o)
				{
					b.Write((int)((数据监视器<游戏方向>)o).V);
				},
				[typeof(数据监视器<对象发型分类>)] = delegate(BinaryWriter b, object o)
				{
					b.Write((int)((数据监视器<对象发型分类>)o).V);
				},
				[typeof(数据监视器<对象发色分类>)] = delegate(BinaryWriter b, object o)
				{
					b.Write((int)((数据监视器<对象发色分类>)o).V);
				},
				[typeof(数据监视器<对象脸型分类>)] = delegate(BinaryWriter b, object o)
				{
					b.Write((int)((数据监视器<对象脸型分类>)o).V);
				},
				[typeof(数据监视器<游戏对象性别>)] = delegate(BinaryWriter b, object o)
				{
					b.Write((int)((数据监视器<游戏对象性别>)o).V);
				},
				[typeof(数据监视器<游戏对象职业>)] = delegate(BinaryWriter b, object o)
				{
					b.Write((int)((数据监视器<游戏对象职业>)o).V);
				},
				[typeof(数据监视器<师门数据>)] = delegate(BinaryWriter b, object o)
				{
					b.Write(((数据监视器<师门数据>)o).V?.数据索引.V ?? 0);
				},
				[typeof(数据监视器<行会数据>)] = delegate(BinaryWriter b, object o)
				{
					b.Write(((数据监视器<行会数据>)o).V?.数据索引.V ?? 0);
				},
				[typeof(数据监视器<队伍数据>)] = delegate(BinaryWriter b, object o)
				{
					b.Write(((数据监视器<队伍数据>)o).V?.数据索引.V ?? 0);
				},
				[typeof(数据监视器<Buff数据>)] = delegate(BinaryWriter b, object o)
				{
					b.Write(((数据监视器<Buff数据>)o).V?.数据索引.V ?? 0);
				},
				[typeof(数据监视器<邮件数据>)] = delegate(BinaryWriter b, object o)
				{
					b.Write(((数据监视器<邮件数据>)o).V?.数据索引.V ?? 0);
				},
				[typeof(数据监视器<账号数据>)] = delegate(BinaryWriter b, object o)
				{
					b.Write(((数据监视器<账号数据>)o).V?.数据索引.V ?? 0);
				},
				[typeof(数据监视器<角色数据>)] = delegate(BinaryWriter b, object o)
				{
					b.Write(((数据监视器<角色数据>)o).V?.数据索引.V ?? 0);
				},
				[typeof(数据监视器<装备数据>)] = delegate(BinaryWriter b, object o)
				{
					b.Write(((数据监视器<装备数据>)o).V?.数据索引.V ?? 0);
				},
				[typeof(数据监视器<物品数据>)] = delegate(BinaryWriter b, object o)
				{
					数据监视器<物品数据> 数据监视器2;
					数据监视器2 = (数据监视器<物品数据>)o;
					b.Write(数据监视器2.V is 装备数据);
					b.Write(数据监视器2.V?.数据索引.V ?? 0);
				},
				[typeof(列表监视器<int>)] = delegate(BinaryWriter b, object o)
				{
					列表监视器<int> 列表监视器11;
					列表监视器11 = (列表监视器<int>)o;
					b.Write(列表监视器11?.Count ?? 0);
					foreach (int item in 列表监视器11)
					{
						b.Write(item);
					}
				},
				[typeof(列表监视器<uint>)] = delegate(BinaryWriter b, object o)
				{
					列表监视器<uint> 列表监视器10;
					列表监视器10 = (列表监视器<uint>)o;
					b.Write(列表监视器10?.Count ?? 0);
					foreach (uint item2 in 列表监视器10)
					{
						b.Write(item2);
					}
				},
				[typeof(列表监视器<bool>)] = delegate(BinaryWriter b, object o)
				{
					列表监视器<bool> 列表监视器9;
					列表监视器9 = (列表监视器<bool>)o;
					b.Write(列表监视器9?.Count ?? 0);
					foreach (bool item3 in 列表监视器9)
					{
						b.Write(item3);
					}
				},
				[typeof(列表监视器<byte>)] = delegate(BinaryWriter b, object o)
				{
					列表监视器<byte> 列表监视器8;
					列表监视器8 = (列表监视器<byte>)o;
					b.Write(列表监视器8?.Count ?? 0);
					foreach (byte item4 in 列表监视器8)
					{
						b.Write(item4);
					}
				},
				[typeof(列表监视器<角色数据>)] = delegate(BinaryWriter b, object o)
				{
					列表监视器<角色数据> 列表监视器7;
					列表监视器7 = (列表监视器<角色数据>)o;
					b.Write(列表监视器7?.Count ?? 0);
					foreach (角色数据 item5 in 列表监视器7)
					{
						b.Write(item5.数据索引.V);
					}
				},
				[typeof(列表监视器<宠物数据>)] = delegate(BinaryWriter b, object o)
				{
					列表监视器<宠物数据> 列表监视器6;
					列表监视器6 = (列表监视器<宠物数据>)o;
					b.Write(列表监视器6?.Count ?? 0);
					foreach (宠物数据 item6 in 列表监视器6)
					{
						b.Write(item6.数据索引.V);
					}
				},
				[typeof(列表监视器<行会数据>)] = delegate(BinaryWriter b, object o)
				{
					列表监视器<行会数据> 列表监视器5;
					列表监视器5 = (列表监视器<行会数据>)o;
					b.Write(列表监视器5?.Count ?? 0);
					foreach (行会数据 item7 in 列表监视器5)
					{
						b.Write(item7.数据索引.V);
					}
				},
				[typeof(列表监视器<行会事记>)] = delegate(BinaryWriter b, object o)
				{
					列表监视器<行会事记> 列表监视器4;
					列表监视器4 = (列表监视器<行会事记>)o;
					b.Write(列表监视器4?.Count ?? 0);
					foreach (行会事记 item8 in 列表监视器4)
					{
						b.Write((byte)item8.事记类型);
						b.Write(item8.第一参数);
						b.Write(item8.第二参数);
						b.Write(item8.第三参数);
						b.Write(item8.第四参数);
						b.Write(item8.事记时间);
					}
				},
				[typeof(列表监视器<随机属性>)] = delegate(BinaryWriter b, object o)
				{
					列表监视器<随机属性> 列表监视器3;
					列表监视器3 = (列表监视器<随机属性>)o;
					b.Write(列表监视器3?.Count ?? 0);
					foreach (随机属性 item9 in 列表监视器3)
					{
						b.Write(item9.属性编号);
					}
				},
				[typeof(列表监视器<装备孔洞颜色>)] = delegate(BinaryWriter b, object o)
				{
					列表监视器<装备孔洞颜色> 列表监视器2;
					列表监视器2 = (列表监视器<装备孔洞颜色>)o;
					b.Write(列表监视器2?.Count ?? 0);
					foreach (装备孔洞颜色 item10 in 列表监视器2)
					{
						b.Write((int)item10);
					}
				},
				[typeof(哈希监视器<宠物数据>)] = delegate(BinaryWriter b, object o)
				{
					哈希监视器<宠物数据> 哈希监视器4;
					哈希监视器4 = (哈希监视器<宠物数据>)o;
					b.Write(哈希监视器4?.Count ?? 0);
					foreach (宠物数据 item11 in 哈希监视器4)
					{
						b.Write(item11.数据索引.V);
					}
				},
				[typeof(哈希监视器<角色数据>)] = delegate(BinaryWriter b, object o)
				{
					哈希监视器<角色数据> 哈希监视器3;
					哈希监视器3 = (哈希监视器<角色数据>)o;
					b.Write(哈希监视器3?.Count ?? 0);
					foreach (角色数据 item12 in 哈希监视器3)
					{
						b.Write(item12.数据索引.V);
					}
				},
				[typeof(哈希监视器<邮件数据>)] = delegate(BinaryWriter b, object o)
				{
					哈希监视器<邮件数据> 哈希监视器2;
					哈希监视器2 = (哈希监视器<邮件数据>)o;
					b.Write(哈希监视器2?.Count ?? 0);
					foreach (邮件数据 item13 in 哈希监视器2)
					{
						b.Write(item13.数据索引.V);
					}
				},
				[typeof(字典监视器<byte, int>)] = delegate(BinaryWriter b, object o)
				{
					字典监视器<byte, int> 字典监视器20;
					字典监视器20 = (字典监视器<byte, int>)o;
					b.Write(字典监视器20?.Count ?? 0);
					foreach (KeyValuePair<byte, int> item14 in 字典监视器20)
					{
						b.Write(item14.Key);
						b.Write(item14.Value);
					}
				},
				[typeof(字典监视器<int, int>)] = delegate(BinaryWriter b, object o)
				{
					字典监视器<int, int> 字典监视器19;
					字典监视器19 = (字典监视器<int, int>)o;
					b.Write(字典监视器19?.Count ?? 0);
					foreach (KeyValuePair<int, int> item15 in 字典监视器19)
					{
						b.Write(item15.Key);
						b.Write(item15.Value);
					}
				},
				[typeof(字典监视器<int, DateTime>)] = delegate(BinaryWriter b, object o)
				{
					字典监视器<int, DateTime> 字典监视器18;
					字典监视器18 = (字典监视器<int, DateTime>)o;
					b.Write(字典监视器18?.Count ?? 0);
					foreach (KeyValuePair<int, DateTime> item16 in 字典监视器18)
					{
						b.Write(item16.Key);
						b.Write(item16.Value.ToBinary());
					}
				},
				[typeof(字典监视器<byte, DateTime>)] = delegate(BinaryWriter b, object o)
				{
					字典监视器<byte, DateTime> 字典监视器17;
					字典监视器17 = (字典监视器<byte, DateTime>)o;
					b.Write(字典监视器17?.Count ?? 0);
					foreach (KeyValuePair<byte, DateTime> item17 in 字典监视器17)
					{
						b.Write(item17.Key);
						b.Write(item17.Value.ToBinary());
					}
				},
				[typeof(字典监视器<string, DateTime>)] = delegate(BinaryWriter b, object o)
				{
					字典监视器<string, DateTime> 字典监视器16;
					字典监视器16 = (字典监视器<string, DateTime>)o;
					b.Write(字典监视器16?.Count ?? 0);
					foreach (KeyValuePair<string, DateTime> item18 in 字典监视器16)
					{
						b.Write(item18.Key);
						b.Write(item18.Value.ToBinary());
					}
				},
				[typeof(字典监视器<byte, 游戏物品>)] = delegate(BinaryWriter b, object o)
				{
					字典监视器<byte, 游戏物品> 字典监视器15;
					字典监视器15 = (字典监视器<byte, 游戏物品>)o;
					b.Write(字典监视器15?.Count ?? 0);
					foreach (KeyValuePair<byte, 游戏物品> item19 in 字典监视器15)
					{
						b.Write(item19.Key);
						b.Write(item19.Value.物品编号);
					}
				},
				[typeof(字典监视器<byte, 铭文技能>)] = delegate(BinaryWriter b, object o)
				{
					字典监视器<byte, 铭文技能> 字典监视器14;
					字典监视器14 = (字典监视器<byte, 铭文技能>)o;
					b.Write(字典监视器14?.Count ?? 0);
					foreach (KeyValuePair<byte, 铭文技能> item20 in 字典监视器14)
					{
						b.Write(item20.Key);
						b.Write(item20.Value.铭文索引);
					}
				},
				[typeof(字典监视器<ushort, Buff数据>)] = delegate(BinaryWriter b, object o)
				{
					字典监视器<ushort, Buff数据> 字典监视器13;
					字典监视器13 = (字典监视器<ushort, Buff数据>)o;
					b.Write(字典监视器13?.Count ?? 0);
					foreach (KeyValuePair<ushort, Buff数据> item21 in 字典监视器13)
					{
						b.Write(item21.Key);
						b.Write(item21.Value.数据索引.V);
					}
				},
				[typeof(字典监视器<ushort, 技能数据>)] = delegate(BinaryWriter b, object o)
				{
					字典监视器<ushort, 技能数据> 字典监视器12;
					字典监视器12 = (字典监视器<ushort, 技能数据>)o;
					b.Write(字典监视器12?.Count ?? 0);
					foreach (KeyValuePair<ushort, 技能数据> item22 in 字典监视器12)
					{
						b.Write(item22.Key);
						b.Write(item22.Value.数据索引.V);
					}
				},
				[typeof(字典监视器<byte, 技能数据>)] = delegate(BinaryWriter b, object o)
				{
					字典监视器<byte, 技能数据> 字典监视器11;
					字典监视器11 = (字典监视器<byte, 技能数据>)o;
					b.Write(字典监视器11?.Count ?? 0);
					foreach (KeyValuePair<byte, 技能数据> item23 in 字典监视器11)
					{
						b.Write(item23.Key);
						b.Write(item23.Value.数据索引.V);
					}
				},
				[typeof(字典监视器<byte, 装备数据>)] = delegate(BinaryWriter b, object o)
				{
					字典监视器<byte, 装备数据> 字典监视器10;
					字典监视器10 = (字典监视器<byte, 装备数据>)o;
					b.Write(字典监视器10?.Count ?? 0);
					foreach (KeyValuePair<byte, 装备数据> item24 in 字典监视器10)
					{
						b.Write(item24.Key);
						b.Write(item24.Value.数据索引.V);
					}
				},
				[typeof(字典监视器<byte, 物品数据>)] = delegate(BinaryWriter b, object o)
				{
					字典监视器<byte, 物品数据> 字典监视器9;
					字典监视器9 = (字典监视器<byte, 物品数据>)o;
					b.Write(字典监视器9?.Count ?? 0);
					foreach (KeyValuePair<byte, 物品数据> item25 in 字典监视器9)
					{
						b.Write(item25.Key);
						b.Write(item25.Value is 装备数据);
						b.Write(item25.Value.数据索引.V);
					}
				},
				[typeof(字典监视器<int, 角色数据>)] = delegate(BinaryWriter b, object o)
				{
					字典监视器<int, 角色数据> 字典监视器8;
					字典监视器8 = (字典监视器<int, 角色数据>)o;
					b.Write(字典监视器8?.Count ?? 0);
					foreach (KeyValuePair<int, 角色数据> item26 in 字典监视器8)
					{
						b.Write(item26.Key);
						b.Write(item26.Value.数据索引.V);
					}
				},
				[typeof(字典监视器<int, 邮件数据>)] = delegate(BinaryWriter b, object o)
				{
					字典监视器<int, 邮件数据> 字典监视器7;
					字典监视器7 = (字典监视器<int, 邮件数据>)o;
					b.Write(字典监视器7?.Count ?? 0);
					foreach (KeyValuePair<int, 邮件数据> item27 in 字典监视器7)
					{
						b.Write(item27.Key);
						b.Write(item27.Value.数据索引.V);
					}
				},
				[typeof(字典监视器<游戏货币, int>)] = delegate(BinaryWriter b, object o)
				{
					字典监视器<游戏货币, int> 字典监视器6;
					字典监视器6 = (字典监视器<游戏货币, int>)o;
					b.Write(字典监视器6?.Count ?? 0);
					foreach (KeyValuePair<游戏货币, int> item28 in 字典监视器6)
					{
						b.Write((int)item28.Key);
						b.Write(item28.Value);
					}
				},
				[typeof(字典监视器<行会数据, DateTime>)] = delegate(BinaryWriter b, object o)
				{
					字典监视器<行会数据, DateTime> 字典监视器5;
					字典监视器5 = (字典监视器<行会数据, DateTime>)o;
					b.Write(字典监视器5?.Count ?? 0);
					foreach (KeyValuePair<行会数据, DateTime> item29 in 字典监视器5)
					{
						b.Write(item29.Key.数据索引.V);
						b.Write(item29.Value.ToBinary());
					}
				},
				[typeof(字典监视器<角色数据, DateTime>)] = delegate(BinaryWriter b, object o)
				{
					字典监视器<角色数据, DateTime> 字典监视器4;
					字典监视器4 = (字典监视器<角色数据, DateTime>)o;
					b.Write(字典监视器4?.Count ?? 0);
					foreach (KeyValuePair<角色数据, DateTime> item30 in 字典监视器4)
					{
						b.Write(item30.Key.数据索引.V);
						b.Write(item30.Value.ToBinary());
					}
				},
				[typeof(字典监视器<角色数据, 行会职位>)] = delegate(BinaryWriter b, object o)
				{
					字典监视器<角色数据, 行会职位> 字典监视器3;
					字典监视器3 = (字典监视器<角色数据, 行会职位>)o;
					b.Write(字典监视器3?.Count ?? 0);
					foreach (KeyValuePair<角色数据, 行会职位> item31 in 字典监视器3)
					{
						b.Write(item31.Key.数据索引.V);
						b.Write((int)item31.Value);
					}
				},
				[typeof(字典监视器<DateTime, 行会数据>)] = delegate(BinaryWriter b, object o)
				{
					字典监视器<DateTime, 行会数据> 字典监视器2;
					字典监视器2 = (字典监视器<DateTime, 行会数据>)o;
					b.Write(字典监视器2?.Count ?? 0);
					foreach (KeyValuePair<DateTime, 行会数据> item32 in 字典监视器2)
					{
						b.Write(item32.Key.ToBinary());
						b.Write(item32.Value.数据索引.V);
					}
				}
			};
		}

		public override string ToString()
		{
			return this.字段名字;
		}

		public 数据字段(BinaryReader 读取流, Type 数据类型)
		{
			Class2.sov79KqzBKBU1();
			//base._002Ector();
			this.字段名字 = 读取流.ReadString();
			this.字段类型 = Type.GetType(读取流.ReadString());
			this.字段详情 = 数据类型?.GetField(this.字段名字);
		}

		public 数据字段(FieldInfo 当前字段)
		{
			Class2.sov79KqzBKBU1();
			//base._002Ector();
			this.字段详情 = 当前字段;
			this.字段名字 = 当前字段.Name;
			this.字段类型 = 当前字段.FieldType;
		}

		public bool 检查字段版本(数据字段 对比字段)
		{
			if (string.Compare(this.字段名字, 对比字段.字段名字, StringComparison.Ordinal) == 0)
			{
				return this.字段类型 == 对比字段.字段类型;
			}
			return false;
		}

		public void 保存字段描述(BinaryWriter 写入流)
		{
			写入流.Write(this.字段名字);
			写入流.Write(this.字段类型.FullName);
		}

		public void 保存字段内容(BinaryWriter 写入流, object 数据)
		{
			数据字段.字段写入方法表[this.字段类型](写入流, 数据);
		}

		public object 读取字段内容(BinaryReader 读取流, object 数据, 数据字段 字段)
		{
			return 数据字段.字段读取方法表[this.字段类型](读取流, (游戏数据)数据, 字段);
		}
	}
}
